package com.example.regular;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author ZhenWuWang
 */
public class Brackets
{
    public static void main(String[] args)
    {
//        match1();
//        match2();
//        match3();
//        match4();
//        match5();
//        match6();
//        match7();
//        match8();
        match9();
    }

    private static void stoutMatchResult(Matcher matcher)
    {
        while (matcher.find())
        {
            System.out.println(matcher.group());
        }
    }

    private static void stoutMatchAllGroup(Matcher matcher)
    {
        //find 进行一次匹配
        while (matcher.find())
        {
            //返回的一个数组，第一个元素是整体匹配结果，然后是各个分组（括号里）匹配的内容
            int count = matcher.groupCount() + 1;
            for (int i = 0; i < count; i++)
            {
                System.out.println(matcher.group(i));
            }
            System.out.println("-----------------------------");
        }
    }

    /**
     * 分组：a+匹配连续出现的“a”，而要匹配连续出现的“ab”时，需要使用(ab)+
     */
    private final static Pattern PATTERN_1 = Pattern.compile("(ab)+");

    private static void match1()
    {
        Matcher matcher = PATTERN_1.matcher("ababa abbb ababab");
//        stoutMatchResult(matcher);
        stoutMatchAllGroup(matcher);
    }

    /**
     * 分支结构
     * 匹配"I love Java" "I love Regular Expression"
     */
    private static void match2()
    {
        String regex = "I love (Java|Regular Expression)";
        System.out.println("I love Java".matches(regex));
        System.out.println("I love Regular Expression".matches(regex));
        System.out.println("I love python".matches(regex));
    }

    /**
     * 提取数据
     */
    private final static Pattern pattern3 = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");

    private static void match3()
    {
        Matcher matcher = pattern3.matcher("2019-07-19");
        stoutMatchAllGroup(matcher);
//        stoutMatchResult(matcher);
    }

    /**
     * 替换:把yyyy-mm-dd格式，替换成mm/dd/yyyy
     */
    private static void match4()
    {
        Matcher matcher = pattern3.matcher("2019-07-19");
        if (matcher.find())
        {
            //返回的一个数组，第一个元素是整体匹配结果，然后是各个分组（括号里）匹配的内容
            System.out.println(matcher.group(1) + "/" + matcher.group(2) + "/" + matcher.group(3));
        }
    }

    /**
     * 括号的反向引用
     * 例子：匹配三种日期格式
     * yyyy-mm-dd
     * yyyy/mm/dd
     * yyyy.mm.dd
     * \1:表示引用前面匹配的第一个括号
     */
    private static void match5()
    {
        String regex = "\\d{4}(-|/|.)\\d{2}\\1\\d{2}";

        String string1 = "2017-06-12";
        String string2 = "2017/06/12";
        String string3 = "2017.06.12";
        String string4 = "2016-06/12";

        System.out.println(string1 + ":" + string1.matches(regex));
        System.out.println(string2 + ":" + string2.matches(regex));
        System.out.println(string3 + ":" + string3.matches(regex));
        System.out.println(string4 + ":" + string4.matches(regex));
    }


    /**
     * 括号的反向引用：括号嵌套
     */
    private final static Pattern PATTERN_6 = Pattern.compile("^((\\d)(\\d(\\d)))\\1\\2\\3\\4$");

    private static void match6()
    {
        Matcher matcher = PATTERN_6.matcher("1231231233");
        if (matcher.find())
        {
            System.out.println("\1表示第一个括号的内容：(\\d)(\\d(\\d))------->" + matcher.group(1));
            System.out.println("\2表示第一个括号的内容：(\\d)------->" + matcher.group(2));
            System.out.println("\3表示第一个括号的内容：(\\d(\\d))------->" + matcher.group(3));
            System.out.println("\4表示第一个括号的内容：(\\d)------->" + matcher.group(4));
        }
    }


    /**
     * 括号的反向引用：\10是表示第10个分组，还是\1和0呢？
     */
    private static void match7()
    {
        String regex = "(1)(2)(3)(4)(5)(6)(7)(8)(9)(#) \\10+";
        String s = "123456789# ######";
        System.out.println("10是否表示第10个分组:" + s.matches(regex));

        regex = "(1)(2)(3)(4)\\5+";
        s = "1234444";
        System.out.println("5是否表示第5个分组:" + s.matches(regex));
    }

    /**
     * 括号的非捕获分组
     * 上面方法出现的分组，都会捕获它们匹配到的数据，以便后续引用，因此也称他们是捕获型分组。
     * 如果只想要括号最原始的功能，但不会引用它，即，既不在API里引用，也不在正则里反向引用。此时可以使用非捕获分组(?:p)
     */
    private final static Pattern PATTERN_8 = Pattern.compile("(?:ab)+");

    private static void match8()
    {
        Matcher matcher = PATTERN_8.matcher("ababa abbb ababab");
        stoutMatchAllGroup(matcher);
    }

    /**
     * 模拟trim方法：去掉字符串开头和结尾的空白字符
     */
    private final static Pattern PATTERN_9 = Pattern.compile("^\\s*(.*)\\s*$");

    private static void match9()
    {
        String s = "   s1 23 dasdasdsAa  ";
        Matcher matcher = PATTERN_9.matcher(s);
        stoutMatchAllGroup(matcher);
        if (matcher.find())
        {
            System.out.println(s + "去掉前后空格:" + matcher.group(1) + "结束");
        }


//        String result = s.replaceAll("^\\s*|\\s*$", "");
//        System.out.println(s + "去掉前后空格:" + result + "结束");
//
//        System.out.println("=====================================================");
//        s = "sas daADa";
//        matcher = PATTERN_9.matcher(s);
//        if (matcher.find())
//        {
//            System.out.println(s + "去掉前后空格:" + matcher.group(1) + "结束");
//        }
//        result = s.replaceAll("^\\s|\\s$", "");
//        System.out.println(s + "去掉前后空格:" + result + "结束");
    }
}
